home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk.zip / DA.C < prev    next >
C/C++ Source or Header  |  1991-04-07  |  10KB  |  387 lines
  1.  
  2. /********************************************
  3. da.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the Awk programming language as defined in
  8. Aho, Kernighan and Weinberger, The AWK Programming Language,
  9. Addison-Wesley, 1988.
  10.  
  11. See the accompaning file, LIMITATIONS, for restrictions
  12. regarding modification and redistribution of this
  13. program in source or binary form.
  14. ********************************************/
  15.  
  16.  
  17. /* $Log:    da.c,v $
  18.  * Revision 2.1  91/04/08  08:22:50  brennan
  19.  * VERSION 0.97
  20.  * 
  21. */
  22.  
  23.  
  24. /*  da.c  */
  25. /*  disassemble code */ 
  26.  
  27.  
  28. #include  "mawk.h"
  29. #include  "code.h"
  30. #include  "bi_funct.h"
  31. #include  "repl.h"
  32. #include  "field.h"
  33.  
  34. char *PROTO(find_bi_name, (PF_CP) ) ;
  35.  
  36. void  da(start, fp)
  37.   INST *start ;
  38.   FILE *fp ;
  39. { CELL *cp ;
  40.   register INST *p = start ;
  41.  
  42.   while ( 1 )
  43.   { /* print the relative code address (label) */
  44.     fprintf(fp,"%03d ", p - start) ;
  45.  
  46.     switch( p++->op )
  47.     {
  48.       case _HALT :  fprintf(fp,"halt\n") ; return ;
  49.       case _STOP :  fprintf(fp,"stop\n") ; break  ;
  50.       case _STOP0 : fprintf(fp, "stop0\n") ; break ;
  51.  
  52.       case _PUSHC :
  53.             cp = (CELL *) p++->ptr ;
  54.             switch( cp->type )
  55.             { case C_DOUBLE :
  56.                   fprintf(fp,"pushc\t%.6g\n" ,  cp ->dval) ;
  57.                   break ;
  58.  
  59.               case C_STRING :
  60.                   fprintf(fp,"pushc\t\"%s\"\n" ,
  61.                           ((STRING *)cp->ptr)->str) ;
  62.                   break ;
  63.  
  64.               case C_RE :
  65.                   fprintf(fp,"pushc\t0x%x\t/%s/\n" , cp->ptr ,
  66.                     re_uncompile(cp->ptr) ) ;
  67.                   break ;
  68.  
  69.               case C_SPACE : 
  70.                   fprintf(fp, "pushc\tspace split\n") ;
  71.                   break ;
  72.  
  73.               case C_SNULL : 
  74.                   fprintf(fp, "pushc\tnull split\n") ;
  75.                   break ;
  76.               case C_REPL  :
  77.                   fprintf(fp, "pushc\trepl\t%s\n" ,
  78.                         repl_uncompile(cp) ) ;
  79.                   break ;
  80.               case C_REPLV :
  81.                   fprintf(fp, "pushc\treplv\t%s\n" ,
  82.                         repl_uncompile(cp) ) ;
  83.                   break ;
  84.                   
  85.               default :
  86.                   fprintf(fp,"pushc\tWEIRD\n") ;  ;
  87.                   break ;
  88.             }
  89.             break ;
  90.  
  91.       case _PUSHA :
  92.             fprintf(fp,"pusha\t0x%x\n", p++ -> ptr) ;
  93.             break ;
  94.  
  95.       case _PUSHI :
  96.             if ( (CELL *)p->ptr == field )
  97.                 fprintf(fp, "pushi\t$0\n") ;
  98.             else fprintf(fp,"pushi\t0x%x\n", p -> ptr) ;
  99.             p++ ;
  100.             break ;
  101.  
  102.       case  L_PUSHA :
  103.             fprintf( fp, "l_pusha\t%d\n", p++->op) ;
  104.             break ;
  105.  
  106.       case  L_PUSHI :
  107.             fprintf( fp, "l_pushi\t%d\n", p++->op) ;
  108.             break ;
  109.  
  110.       case  LAE_PUSHI :
  111.             fprintf( fp, "lae_pushi\t%d\n", p++->op) ;
  112.             break ;
  113.  
  114.       case  LAE_PUSHA :
  115.             fprintf( fp, "lae_pusha\t%d\n", p++->op) ;
  116.             break ;
  117.  
  118.       case  LA_PUSHA :
  119.             fprintf( fp, "la_pusha\t%d\n", p++->op) ;
  120.             break ;
  121.  
  122.       case F_PUSHA :
  123.             fprintf(fp,"f_pusha\t$%d\n" , (CELL *) p++->ptr - field ) ;
  124.             break ;
  125.  
  126.       case F_PUSHI :
  127.             fprintf(fp,"f_pushi\t$%d\n" , (CELL *) p++->ptr - field ) ;
  128.             break ;
  129.  
  130.       case FE_PUSHA :
  131.             fprintf(fp,"fe_pusha\n" ) ;
  132.             break ;
  133.  
  134.       case FE_PUSHI :
  135.             fprintf(fp,"fe_pushi\n" ) ;
  136.             break ;
  137.  
  138.       case AE_PUSHA :
  139.             fprintf(fp,"ae_pusha\t0x%x\n" , p++->ptr) ;
  140.             break ;
  141.  
  142.       case AE_PUSHI :
  143.             fprintf(fp,"ae_pushi\t0x%x\n" , p++->ptr) ;
  144.             break ;
  145.  
  146.       case A_PUSHA :
  147.             fprintf(fp,"a_pusha\t0x%x\n" , p++->ptr) ;
  148.             break ;
  149.  
  150.       case A_TEST :
  151.             fprintf(fp,"a_test\n" ) ;
  152.             break ;
  153.  
  154.       case A_DEL :
  155.             fprintf(fp,"a_del\n" ) ;
  156.             break ;
  157.  
  158.       case A_CAT :
  159.             fprintf(fp,"a_cat\t%d\n", p++->op ) ;
  160.             break ;
  161.  
  162.       case _POP :
  163.             fprintf(fp,"pop\n") ;
  164.             break ;
  165.  
  166.       case  _ADD :
  167.             fprintf(fp,"add\n") ; break ;
  168.  
  169.       case  _SUB :
  170.             fprintf(fp,"sub\n") ; break ;
  171.       case  _MUL :
  172.             fprintf(fp,"mul\n") ; break ;
  173.       case  _DIV :
  174.             fprintf(fp,"div\n") ; break ;
  175.       case  _MOD :
  176.             fprintf(fp,"mod\n") ; break ;
  177.       case  _POW :
  178.             fprintf(fp,"pow\n") ; break ;
  179.       case  _NOT :
  180.             fprintf(fp,"not\n") ; break ;
  181.       case  _UMINUS :
  182.             fprintf(fp,"uminus\n") ; break ;
  183.       case  _UPLUS :
  184.             fprintf(fp,"plus\n") ; break ;
  185.       case  _DUP :
  186.             fprintf(fp,"dup\n") ; break ;
  187.       case  _TEST :
  188.             fprintf(fp,"test\n") ; break ;
  189.  
  190.       case  _CAT  :
  191.             fprintf(fp,"cat\n") ; break ;
  192.  
  193.       case  _ASSIGN :
  194.             fprintf(fp,"assign\n") ; break ;
  195.       case  _ADD_ASG :
  196.             fprintf(fp,"add_asg\n") ; break ;
  197.       case  _SUB_ASG :
  198.             fprintf(fp,"sub_asg\n") ; break ;
  199.       case  _MUL_ASG :
  200.             fprintf(fp,"mul_asg\n") ; break ;
  201.       case  _DIV_ASG :
  202.             fprintf(fp,"div_asg\n") ; break ;
  203.       case  _MOD_ASG :
  204.             fprintf(fp,"mod_asg\n") ; break ;
  205.       case  _POW_ASG :
  206.             fprintf(fp,"pow_asg\n") ; break ;
  207.  
  208.       case  F_ASSIGN :
  209.             fprintf(fp,"f_assign\n") ; break ;
  210.       case  F_ADD_ASG :
  211.             fprintf(fp,"f_add_asg\n") ; break ;
  212.       case  F_SUB_ASG :
  213.             fprintf(fp,"f_sub_asg\n") ; break ;
  214.       case  F_MUL_ASG :
  215.             fprintf(fp,"f_mul_asg\n") ; break ;
  216.       case  F_DIV_ASG :
  217.             fprintf(fp,"f_div_asg\n") ; break ;
  218.       case  F_MOD_ASG :
  219.             fprintf(fp,"f_mod_asg\n") ; break ;
  220.       case  F_POW_ASG :
  221.             fprintf(fp,"f_pow_asg\n") ; break ;
  222.  
  223.       case  _PUSHINT :
  224.             fprintf(fp,"pushint\t%d\n" , p++ -> op ) ;
  225.             break ;
  226.  
  227.       case  _BUILTIN  :
  228.             fprintf(fp,"%s\n" , 
  229.                     find_bi_name( (PF_CP) p++ -> ptr ) ) ;
  230.             break ;
  231.  
  232.       case  _PRINT :
  233.             fprintf(fp,"%s\n", 
  234.             (PF_CP) p++ -> ptr == bi_printf
  235.                 ? "printf" : "print") ;
  236.             break ;
  237.       
  238.       case  _POST_INC :
  239.             fprintf(fp,"post_inc\n") ; break ;
  240.  
  241.       case  _POST_DEC :
  242.             fprintf(fp,"post_dec\n") ; break ;
  243.  
  244.       case  _PRE_INC :
  245.             fprintf(fp,"pre_inc\n") ; break ;
  246.  
  247.       case  _PRE_DEC :
  248.             fprintf(fp,"pre_dec\n") ; break ;
  249.  
  250.       case  F_POST_INC :
  251.             fprintf(fp,"f_post_inc\n") ; break ;
  252.  
  253.       case  F_POST_DEC :
  254.             fprintf(fp,"f_post_dec\n") ; break ;
  255.  
  256.       case  F_PRE_INC :
  257.             fprintf(fp,"f_pre_inc\n") ; break ;
  258.  
  259.       case  F_PRE_DEC :
  260.             fprintf(fp,"f_pre_dec\n") ; break ;
  261.  
  262.       case  _JMP :
  263.       case  _JNZ :
  264.       case  _JZ  :
  265.           { int j = (p-1)->op ;
  266.             char *s = j == _JMP ? "jmp" : 
  267.                       j == _JNZ ? "jnz" : "jz" ;
  268.  
  269.             fprintf(fp,"%s\t\t%03d\n" , s ,
  270.               (p - start) + p->op - 1 ) ;
  271.             p++ ;
  272.             break ;
  273.           }
  274.     
  275.       case  _EQ  :
  276.             fprintf(fp,"eq\n") ; break ;
  277.  
  278.       case  _NEQ  :
  279.             fprintf(fp,"neq\n") ; break ;
  280.  
  281.       case  _LT  :
  282.             fprintf(fp,"lt\n") ; break ;
  283.  
  284.       case  _LTE  :
  285.             fprintf(fp,"lte\n") ; break ;
  286.  
  287.       case  _GT  :
  288.             fprintf(fp,"gt\n") ; break ;
  289.  
  290.       case  _GTE  :
  291.             fprintf(fp,"gte\n") ; break ;
  292.  
  293.       case  _MATCH :
  294.             fprintf(fp,"match_op\n") ; break ;
  295.  
  296.       case  A_LOOP :
  297.             fprintf(fp,"a_loop\t%03d\n", p-start+p[1].op) ;
  298.             p += 2 ;
  299.             break ;
  300.  
  301.       case  _EXIT  :
  302.             fprintf(fp, "exit\n") ; break ;
  303.  
  304.       case  _EXIT0  :
  305.             fprintf(fp, "exit0\n") ; break ;
  306.  
  307.       case  _NEXT  :
  308.             fprintf(fp, "next\n") ; break ;
  309.  
  310.       case  _RET  :
  311.             fprintf(fp, "ret\n") ; break ;
  312.       case  _RET0 :
  313.             fprintf(fp, "ret0\n") ; break ;
  314.  
  315.       case  _CALL :
  316.             fprintf(fp, "call\t%s\t%d\n", 
  317.                 ((FBLOCK*)p->ptr)->name , p[1].op) ;
  318.             p += 2 ;
  319.             break ;
  320.  
  321.       case  _RANGE :
  322.             fprintf(fp, "range\t%03d %03d %03d\n",
  323.               /* label for pat2, action, follow */
  324.               p - start + p[1].op ,
  325.               p - start + p[2].op ,
  326.               p - start + p[3].op ) ;
  327.             p += 4 ; 
  328.             break ;
  329.       default :
  330.             fprintf(fp,"bad instruction\n") ;
  331.             return ;
  332.     }
  333.   }
  334. }
  335.  
  336. static struct {
  337. PF_CP action ;
  338. char *name ;
  339. } special_cases[] = {
  340. bi_length, "length",
  341. bi_split, "split",
  342. bi_match, "match",
  343. bi_getline,"getline",
  344. bi_sub, "sub",
  345. bi_gsub , "gsub",
  346. (PF_CP) 0, (char *) 0 } ;
  347.  
  348. static char *find_bi_name( p )
  349.   PF_CP p ;
  350. { BI_REC *q ;
  351.   int i ;
  352.  
  353.   for( q = bi_funct ; q->name ; q++ )
  354.     if ( q->fp == p )  /* found */
  355.         return q->name ;
  356.   /* next check some special cases */
  357.   for( i = 0 ; special_cases[i].action ; i++)
  358.     if ( special_cases[i].action == p )
  359.         return  special_cases[i].name ;
  360.  
  361.   return  "unknown builtin" ;
  362. }
  363.  
  364. static struct fdump {
  365. struct fdump *link ;
  366. FBLOCK  *fbp ;
  367. }  *fdump_list ;  /* linked list of all user functions */
  368.  
  369. void add_to_fdump_list( fbp )
  370.   FBLOCK *fbp ;
  371. { struct fdump *p = (struct fdump *)zmalloc(sizeof(struct fdump)) ;
  372.   p->fbp = fbp ;
  373.   p->link = fdump_list ;  fdump_list = p ;
  374. }
  375.  
  376. void  fdump()
  377. {
  378.   register struct fdump *p, *q = fdump_list ;
  379.  
  380.   while ( p = q )
  381.   { q = p->link ;
  382.     fprintf(stderr, "function %s\n" , p->fbp->name) ;
  383.     da(p->fbp->code, stderr) ;
  384.     zfree(p, sizeof(struct fdump)) ;
  385.   }
  386. }
  387.